home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Rozne / HTTrack 3.40-2 / httrack-3.40-2.exe / {app} / src / htsindex.c < prev    next >
C/C++ Source or Header  |  2006-01-21  |  15KB  |  494 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: htsindex.c                                             */
  34. /*       keyword indexing system (search index)                 */
  35. /* Author: Xavier Roche                                         */
  36. /* ------------------------------------------------------------ */
  37.  
  38. /* Internal engine bytecode */
  39. #define HTS_INTERNAL_BYTECODE
  40.  
  41.  
  42. #include "htsindex.h"
  43. #include "htsglobal.h"
  44. #include "htslib.h"
  45.  
  46. #if HTS_MAKE_KEYWORD_INDEX
  47. #include "htshash.h"
  48. #include "htsinthash.h"
  49.  
  50.  
  51. /* Keyword Indexer Parameters */
  52.  
  53. // Maximum length for a keyword
  54. #define KEYW_LEN             50
  55. // Minimum length for a keyword - MUST NOT BE NULL!!!
  56. #define KEYW_MIN_LEN         3
  57. // What characters to accept? - MUST NOT BE EMPTY AND MUST NOT CONTAIN THE SPACE (32) CHARACTER!!!
  58. #define KEYW_ACCEPT          "abcdefghijklmnopqrstuvwxyz0123456789-_."
  59. // Convert A to a, and so on.. to avoid case problems in indexing
  60. // This can be a generic table, containing characters that are in fact not accepted by KEYW_ACCEPT
  61. // MUST HAVE SAME SIZES!!
  62. #define KEYW_TRANSCODE_FROM  (\
  63.                                "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
  64.                                "αΓΣ" \
  65.                                "└┬─" \
  66.                                "ΘΦΩδ" \
  67.                                "╚╚╩╦" \
  68.                                "∞ε∩" \
  69.                                "╠╬╧" \
  70.                                "≥⌠÷" \
  71.                                "╥╘╓" \
  72.                                "∙√ⁿ" \
  73.                                "┘█▄" \
  74.                                " " \
  75.                              )
  76. #define KEYW_TRANSCODE_TO    ( \
  77.                                "abcdefghijklmnopqrstuvwxyz" \
  78.                                "aaa" \
  79.                                "aaa" \
  80.                                "eeee" \
  81.                                "eeee" \
  82.                                "iii" \
  83.                                "iii" \
  84.                                "ooo" \
  85.                                "ooo" \
  86.                                "uuu" \
  87.                                "uuu" \
  88.                                "y" \
  89.                              )
  90. // These (accepted) characters will be ignored at begining of a keyword
  91. #define KEYW_IGNORE_BEG       "-_."
  92. // These (accepted) characters will be stripped if at the end of a keyword
  93. #define KEYW_STRIP_END       "-_."
  94. // Words begining with these (accepted) characters will be ignored
  95. #define KEYW_NOT_BEG         "0123456789"
  96. // Treat these characters as space characters - MUST NOT BE EMPTY!!!
  97. #define KEYW_SPACE           " ',;:!?\"\x0d\x0a\x09\x0b\x0c"
  98. // Common words (the,for..) detector
  99. // If a word represents more than KEYW_USELESS1K (%1000) of total words, then ignore it
  100. // 5 (0.5%)
  101. #define KEYW_USELESS1K       5
  102. // If a word is present in more than KEYW_USELESS1KPG (%1000) pages, then ignore it
  103. // 800 (80%)
  104. #define KEYW_USELESS1KPG     800
  105. // This number will be reduced by index hit for sorting purpose
  106. // leave it as it is here if you don't REALLY know what you are doing
  107. // Yes, I may be the only person, maybe
  108. #define KEYW_SORT_MAXCOUNT 999999999
  109.  
  110. /* End of Keyword Indexer Parameters */
  111.  
  112. int strcpos(char* adr,char c);
  113. int mystrcmp(const void* _e1,const void* _e2);
  114.  
  115. // Global variables
  116. int hts_index_init=1;
  117. int hts_primindex_size=0;
  118. FILE* fp_tmpproject=NULL;
  119. int hts_primindex_words=0;
  120.  
  121. #endif
  122.  
  123. /* 
  124.   Init index 
  125. */
  126. void index_init(const char* indexpath) {
  127. #if HTS_MAKE_KEYWORD_INDEX
  128. #ifndef _WIN32_WCE
  129.   /* remove(concat(indexpath,"index.txt")); */
  130.   hts_index_init=1;
  131.   hts_primindex_size=0;
  132.   hts_primindex_words=0;
  133.   fp_tmpproject=tmpfile();
  134. #endif
  135. #endif
  136. }
  137.  
  138.  
  139. /* 
  140.    Indexing system
  141.    A little bit dirty, (quick'n dirty, in fact)
  142.    But should be okay on most cases
  143.    Tags and javascript handled (ignored)
  144. */
  145. int index_keyword(const char* html_data,LLint size,const char* mime,const char* filename,const char* indexpath) {
  146. #if HTS_MAKE_KEYWORD_INDEX
  147.   int intag=0,inscript=0,incomment=0;
  148.   char keyword[KEYW_LEN+32];
  149.   int i=0;
  150.   //
  151.   int WordIndexSize=1024;
  152.   inthash WordIndexHash=NULL;
  153.   FILE *tmpfp=NULL;
  154.   //
  155.  
  156.   // Check parameters
  157.   if (!html_data)
  158.     return 0;
  159.   if (!size)
  160.     return 0;
  161.   if (!mime)
  162.     return 0;
  163.   if (!filename)
  164.     return 0;
  165.  
  166.   // Init ?
  167.   if (hts_index_init) {
  168.     remove(concat(indexpath,"index.txt"));
  169.     remove(concat(indexpath,"sindex.html"));
  170.     hts_index_init=0;
  171.   }
  172.  
  173.   // Check MIME type
  174.   if (strfield2(mime,"text/html")) {
  175.     inscript=0;
  176.   } 
  177.   // FIXME - temporary fix for image/svg+xml (svg)
  178.   // "IN XML" (html like, in fact :) )
  179.   else if (
  180.     (strfield2(mime,"image/svg+xml"))
  181.     ||
  182.     (strfield2(mime,"image/svg-xml"))
  183. #if HTS_USEMMS
  184.         ||
  185.         strfield2(mime,"video/x-ms-asf")
  186. #endif
  187.     ) {
  188.     inscript=0;
  189.   }
  190.   else if (
  191.     (strfield2(mime,"application/x-javascript"))
  192.     || (strfield2(mime,"text/css"))
  193.     ) {
  194.     inscript=1;
  195.   //} else if (strfield2(mime, "text/vnd.wap.wml")) {   // humm won't work in many cases
  196.   //  inscript=0;
  197.   } else
  198.     return 0;
  199.  
  200.   // Temporary file
  201.   tmpfp = tmpfile();
  202.   if (!tmpfp)
  203.     return 0;
  204.  
  205.   // Create hash structure
  206.   // Hash tables rulez da world!
  207.   WordIndexHash=inthash_new(WordIndexSize);
  208.   if (!WordIndexHash)
  209.     return 0;
  210.  
  211.   // Start indexing this page
  212.   keyword[0]='\0';
  213.   while(i<size) {
  214.     if (strfield(html_data + i , "<script")) {
  215.       inscript=1;
  216.     } 
  217.     else if (strfield(html_data + i , "<!--")) {
  218.       incomment=1;
  219.     }
  220.     else if (strfield(html_data + i , "</script")) {
  221.       if (!incomment)
  222.         inscript=0;
  223.     } 
  224.     else if (strfield(html_data + i , "-->")) {
  225.       incomment=0;
  226.     }
  227.     else if (html_data[i]=='<') {
  228.       if (!inscript)
  229.         intag=1;
  230.     }    
  231.     else if (html_data[i]=='>') {
  232.       intag=0;
  233.     }    
  234.     else {    
  235.       // Okay, parse keywords
  236.       if ( (!inscript) && (!incomment) && (!intag) ) {
  237.         char cchar=html_data[i];
  238.         int pos;
  239.         int len=strlen(keyword);
  240.         
  241.         // Replace (ignore case, and so on..)
  242.         if ((pos=strcpos(KEYW_TRANSCODE_FROM,cchar))>=0)
  243.           cchar=KEYW_TRANSCODE_TO[pos];
  244.         
  245.         if (strchr(KEYW_ACCEPT,cchar)) {
  246.           /* Ignore some characters at begining */
  247.           if ((len>0) || (!strchr(KEYW_IGNORE_BEG,cchar))) {
  248.             keyword[len++]=cchar;
  249.             keyword[len]='\0';
  250.           }
  251.         } else if ( (strchr(KEYW_SPACE,cchar)) || (!cchar) ) {
  252.  
  253.  
  254.           /* Avoid these words */
  255.           if (len>0) {
  256.             if (strchr(KEYW_NOT_BEG,keyword[0])) {
  257.               keyword[(len=0)]='\0';
  258.             }
  259.           }
  260.  
  261.           /* Strip ending . and so */
  262.           {
  263.             int ok=0;
  264.             while((len=strlen(keyword)) && (!ok)) {
  265.               if (strchr(KEYW_STRIP_END,keyword[len-1])) {      /* strip it */
  266.                 keyword[len-1]='\0';
  267.               } else
  268.                 ok=1;
  269.             }
  270.           }
  271.           
  272.           /* Store it ? */
  273.           if (len >= KEYW_MIN_LEN ) {
  274.             hts_primindex_words++;
  275.             if (inthash_inc(WordIndexHash,keyword)) {   /* added new */
  276.               fprintf(tmpfp,"%s\n",keyword);
  277.             }
  278.           }
  279.           keyword[(len=0)]='\0';
  280.         } else      /* Invalid */
  281.           keyword[(len=0)]='\0';
  282.  
  283.         if (len>KEYW_LEN) {
  284.           keyword[(len=0)]='\0';
  285.         }
  286.       }
  287.       
  288.     }
  289.     
  290.     i++;
  291.   }
  292.  
  293.   // Reset temp file
  294.   fseek(tmpfp,0,SEEK_SET);
  295.  
  296.   // Process indexing for this page
  297.   {
  298.     //FILE* fp=NULL;
  299.     //fp=fopen(concat(indexpath,"index.txt"),"ab");
  300.     if (fp_tmpproject) {
  301.       while(!feof(tmpfp)) {
  302.         char line[KEYW_LEN + 32];
  303.         linput(tmpfp,line,KEYW_LEN + 2);
  304.         if (strnotempty(line)) {
  305.           unsigned long int e=0;
  306.           if (inthash_read(WordIndexHash,line,&e)) {
  307.             //if (e) {
  308.             char BIGSTK savelst[HTS_URLMAXSIZE*2];
  309.             e++;          /* 0 means "once" */
  310.             
  311.             if (strncmp((const char*)fslash((char*)indexpath),filename,strlen(indexpath))==0)  // couper
  312.               strcpybuff(savelst,filename+strlen(indexpath));
  313.             else
  314.               strcpybuff(savelst,filename);
  315.             
  316.             // Add entry for this file and word
  317.             fprintf(fp_tmpproject,"%s %d %s\n",line,(int) (KEYW_SORT_MAXCOUNT - e),savelst);
  318.             hts_primindex_size++;
  319.             //}
  320.           }
  321.         }
  322.       }
  323.       //fclose(fp);
  324.     }
  325.   }
  326.  
  327.   // Delete temp file
  328.   fclose(tmpfp);
  329.   tmpfp=NULL;
  330.  
  331.   // Clear hash table
  332.   inthash_delete(&WordIndexHash);
  333. #endif
  334.   return 1;
  335. }
  336.  
  337. /*
  338.   Sort index!
  339. */
  340. void index_finish(const char* indexpath,int mode) {
  341. #if HTS_MAKE_KEYWORD_INDEX
  342.   char** tab;
  343.   char* blk;
  344.   INTsys size;
  345.   
  346.   size=fpsize(fp_tmpproject);
  347.   if (size>0) {
  348.     //FILE* fp=fopen(concat(indexpath,"index.txt"),"rb");
  349.     if (fp_tmpproject) {
  350.       tab=(char**)malloct(sizeof(char*) * (hts_primindex_size+2) );
  351.       if (tab) {
  352.         blk = malloct(size+4);
  353.         if (blk) {
  354.           fseek(fp_tmpproject,0,SEEK_SET);
  355.           if ((INTsys)fread(blk,1,size,fp_tmpproject) == size) {
  356.             char *a=blk,*b;
  357.             int index=0;
  358.             int i;
  359.             FILE* fp;
  360.  
  361.             while( (b=strchr(a,'\n')) && (index < hts_primindex_size) ) {
  362.               tab[index++]=a;
  363.               *b='\0';
  364.               a=b+1;
  365.             }
  366.             
  367.             // Sort it!
  368.             qsort(tab,index,sizeof(char*),mystrcmp);
  369.  
  370.             // Delete fp_tmpproject
  371.             fclose(fp_tmpproject);
  372.             fp_tmpproject=NULL;
  373.  
  374.             // Write new file
  375.             if (mode == 1)      // TEXT
  376.               fp=fopen(concat(indexpath,"index.txt"),"wb");
  377.             else                // HTML
  378.               fp=fopen(concat(indexpath,"sindex.html"),"wb");
  379.             if (fp) {
  380.               char current_word[KEYW_LEN + 32];
  381.               char word[KEYW_LEN + 32];
  382.               int hit;
  383.               int total_hit=0;
  384.               int total_line=0;
  385.               int last_pos=0;
  386.               char word0='\0';
  387.               current_word[0]='\0';
  388.  
  389.               if (mode == 2) {         // HTML
  390.                 for(i=0;i<index;i++) {
  391.                   if (word0 != tab[i][0]) {
  392.                     word0 = tab[i][0];
  393.                     fprintf(fp," <a href=\"#%c\">%c</a>\r\n",word0,word0);
  394.                   }
  395.                 }
  396.                 word0='\0';
  397.                 fprintf(fp,"<br><br>\r\n");
  398.                 fprintf(fp,"<table width=\"100%%\" border=\"0\">\r\n<tr>\r\n<td>word</td>\r\n<td>location\r\n");
  399.               }
  400.  
  401.               for(i=0;i<index;i++) {
  402.                 if (sscanf(tab[i],"%s %d",word,&hit) == 2) {
  403.                   char*  a=strchr(tab[i],' ');
  404.                   if (a) a=strchr(a+1,' ');
  405.                   if (a++) {                            /* Yes, a++, not ++a :) */
  406.                     hit=KEYW_SORT_MAXCOUNT-hit;
  407.                     if (strcmp(word,current_word)) {    /* New word */
  408.                       if (total_hit) {
  409.                         if (mode == 1)      // TEXT
  410.                           fprintf(fp,"\t=%d\r\n",total_hit);
  411.                         //else                // HTML
  412.                         //  fprintf(fp,"<br>(%d total hits)\r\n",total_hit);
  413.                         if ( 
  414.                               ( ((total_hit*1000 ) / hts_primindex_words) >= KEYW_USELESS1K   )
  415.                             ||
  416.                               ( ((total_line*1000) / index              ) >= KEYW_USELESS1KPG )
  417.                           ) {
  418.                           fseek(fp,last_pos,SEEK_SET);
  419.                           if (mode == 1)      // TEXT
  420.                             fprintf(fp,"\tignored (%d)\r\n",((total_hit*1000)/hts_primindex_words));
  421.                           else
  422.                             fprintf(fp,"(ignored) [%d hits]<br>\r\n",total_hit);
  423.                         }
  424.                         else {
  425.                           if (mode == 1)      // TEXT
  426.                             fprintf(fp,"\t(%d)\r\n",((total_hit*1000)/hts_primindex_words));
  427.                           //else                // HTML
  428.                           //  fprintf(fp,"(%d)\r\n",((total_hit*1000)/hts_primindex_words));
  429.                         }
  430.                       }
  431.                       if (mode == 1)      // TEXT
  432.                         fprintf(fp,"%s\r\n",word);
  433.                       else {              // HTML
  434.                         fprintf(fp,"</td></tr>\r\n");
  435.                         if (word0 != word[0]) {
  436.                           word0 = word[0];
  437.                           fprintf(fp,"<th>%c</th>\r\n",word0);
  438.                           fprintf(fp,"<a name=\"%c\"></a>\r\n",word0);
  439.                         }
  440.                         fprintf(fp,"<tr>\r\n<td>%s</td>\r\n<td>\r\n",word);
  441.                       }
  442.                       fflush(fp); last_pos=ftell(fp);
  443.                       strcpybuff(current_word,word);
  444.                       total_hit=total_line=0;
  445.                     }
  446.                     total_hit+=hit;
  447.                     total_line++;
  448.                     if (mode == 1)      // TEXT
  449.                       fprintf(fp,"\t%d %s\r\n",hit,a);
  450.                     else                // HTML
  451.                       fprintf(fp,"<a href=\"%s\">%s</a> [%d hits]<br>\r\n",a,a,hit);
  452.                   }
  453.                 }
  454.               }
  455.               if (mode == 2)         // HTML
  456.                 fprintf(fp,"</td></tr>\r\n</table>\r\n");
  457.               fclose(fp);
  458.             }
  459.             
  460.           }
  461.           freet(blk);
  462.         }
  463.         freet(tab);
  464.       }
  465.  
  466.     }
  467.     //qsort
  468.   }
  469.   if (fp_tmpproject)
  470.     fclose(fp_tmpproject);
  471.   fp_tmpproject=NULL;
  472. #endif
  473. }
  474.  
  475.  
  476. /* Subroutines */
  477.  
  478. #if HTS_MAKE_KEYWORD_INDEX
  479. int strcpos(char* adr,char c) {
  480.   char* apos=strchr(adr,c);
  481.   if (apos)
  482.     return (int)(apos-adr);
  483.   else
  484.     return -1;
  485. }
  486.  
  487. int mystrcmp(const void* _e1,const void* _e2) {
  488.   char** e1=(char**)_e1;
  489.   char** e2=(char**)_e2;
  490.   return strcmp(*e1,*e2);
  491. }
  492. #endif
  493.  
  494.